package fr.charlott.business.service.impl;

import java.util.ArrayList;
import java.util.List;

import org.dozer.DozerBeanMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import fr.charlott.business.dto.SaisonDTO;
import fr.charlott.business.service.SaisonService;
import fr.charlott.core.repository.model.Saison;

@Service("saisonService")
public class SaisonServiceImpl implements SaisonService {

	private fr.charlott.core.service.SaisonService saisonService;

	private DozerBeanMapper dozerMapper;

	public SaisonServiceImpl() {
		super();
	}

	@Autowired(required = true)
	public SaisonServiceImpl(fr.charlott.core.service.SaisonService saisonService, DozerBeanMapper dozerMapper) {
		this();
		this.saisonService = saisonService;
		this.dozerMapper = dozerMapper;
	}

	@Override
	@Transactional(readOnly = true)
	public SaisonDTO chargerParAnnee(short annee) {
		Saison saison = saisonService.chargerParAnnee(annee);
		if (saison != null){
			return dozerMapper.map(saison, SaisonDTO.class);
		}
		return null;
	}

	@Override
	@Transactional(readOnly = true)
	public List<SaisonDTO> chargerTousLesSaisons() {
		List<SaisonDTO> listeSaisons = new ArrayList<SaisonDTO>();
		for (Saison saison : saisonService.chargerTousLesSaisons()) {
			listeSaisons.add(dozerMapper.map(saison, SaisonDTO.class));
		}
		return listeSaisons;
	}

	@Override
	@Transactional(readOnly = true)
	public SaisonDTO chargerSaisonCourante() {
		return dozerMapper.map(saisonService.chargerSaisonCourante(), SaisonDTO.class);
	}

	@Override
	@Transactional
	public void ajouterSaison(SaisonDTO saisonDTO) {
		// Si c'est la saison courante on positionne toutes les saisons comme non courante
		if(saisonDTO.isSaisonCourante()) {
			saisonService.reinitialiserToutesLesSaisons();
		}
		saisonService.ajouterSaison(dozerMapper.map(saisonDTO, Saison.class));
	}
	
	@Override
	@Transactional
	public void supprimerSaison(SaisonDTO saisonDTO) {
		saisonService.supprimerSaison(dozerMapper.map(saisonDTO, Saison.class));
	}
	
	@Override
	@Transactional
	public void supprimerToutesLesSaisons() {
		saisonService.supprimerToutesLesSaisons();
	}


	// getters - setters

	/**
	 * @param dozerMapper
	 *            the dozerMapper to set
	 */
	public void setDozerMapper(DozerBeanMapper dozerMapper) {
		this.dozerMapper = dozerMapper;
	}

	/**
	 * @param saisonService
	 *            the saisonService to set
	 */
	public void setSaisonService(fr.charlott.core.service.SaisonService saisonService) {
		this.saisonService = saisonService;
	}

}
